home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Burning & Media / GB-PVR 1.2.13 / GBPVR10213.msi / Cabs.w1.cab / IPList.cs533 < prev    next >
Encoding:
Text File  |  2006-07-15  |  9.1 KB  |  268 lines
  1. // Copyright by Bo Norgaard, All rights reserved.
  2. // http://www.codeproject.com/csharp/ipnumbers.asp
  3.  
  4. using System;
  5. using System.Text;
  6. using System.Collections;
  7.  
  8.  
  9. namespace IPNumbers
  10. {
  11.     /// <summary>
  12.     /// Internal class for storing a range of IP numbers with the same IP mask
  13.     /// </summary>
  14.     public class IPArrayList {
  15.         private bool isSorted = false;
  16.         private ArrayList ipNumList = new ArrayList();
  17.         private uint ipmask;
  18.  
  19.         /// <summary>
  20.         /// Constructor that sets the mask for the list
  21.         /// </summary>
  22.         public IPArrayList(uint mask) {
  23.             ipmask = mask;
  24.         }
  25.  
  26.         /// <summary>
  27.         /// Add a new IP numer (range) to the list
  28.         /// </summary>
  29.         public void Add(uint IPNum) {
  30.             isSorted = false;
  31.             ipNumList.Add(IPNum & ipmask);
  32.         }
  33.  
  34.         /// <summary>
  35.         /// Checks if an IP number is within the ranges included by the list
  36.         /// </summary>
  37.         public bool Check(uint IPNum) {
  38.             bool found = false;
  39.             if (ipNumList.Count>0) {
  40.                 if (!isSorted) {
  41.                     ipNumList.Sort();
  42.                     isSorted=true;
  43.                 }
  44.                 IPNum = IPNum & ipmask;
  45.                 if (ipNumList.BinarySearch(IPNum)>=0) found=true;
  46.             }
  47.             return found;
  48.         }
  49.  
  50.         /// <summary>
  51.         /// Clears the list
  52.         /// </summary>
  53.         public void Clear() {
  54.             ipNumList.Clear();
  55.             isSorted = false;
  56.         }
  57.  
  58.         /// <summary>
  59.         /// The ToString is overriden to generate a list of the IP numbers
  60.         /// </summary>
  61.         public override string ToString() {
  62.             StringBuilder buf = new StringBuilder();
  63.             foreach (uint ipnum in ipNumList) {
  64.                 if (buf.Length>0) buf.Append("\r\n");
  65.                 buf.Append(((int)ipnum & 0xFF000000) >> 24).Append('.');
  66.                 buf.Append(((int)ipnum & 0x00FF0000) >> 16).Append('.');
  67.                 buf.Append(((int)ipnum & 0x0000FF00) >> 8).Append('.');
  68.                 buf.Append(((int)ipnum & 0x000000FF));
  69.             }
  70.             return buf.ToString();
  71.         }
  72.  
  73.         /// <summary>
  74.         /// The IP mask for this list of IP numbers
  75.         /// </summary>
  76.         public uint Mask {
  77.             get {
  78.                 return ipmask;
  79.             }
  80.         }
  81.     }
  82.  
  83.     /// <summary>
  84.     /// Summary description for Class1.
  85.     /// </summary>
  86.     public class IPList
  87.     {   private ArrayList ipRangeList = new ArrayList();
  88.         private SortedList maskList = new SortedList();
  89.         private ArrayList usedList = new ArrayList();
  90.  
  91.         public IPList()
  92.         {
  93.             // Initialize IP mask list and create IPArrayList into the ipRangeList
  94.             uint mask = 0x00000000;
  95.             for(int level = 1; level<33; level++) {
  96.                 mask = (mask >> 1) | 0x80000000;
  97.                 maskList.Add(mask,level);
  98.                 ipRangeList.Add(new IPArrayList(mask));
  99.             }
  100.         }
  101.  
  102.         // Parse a String IP address to a 32 bit unsigned integer
  103.         // We can't use System.Net.IPAddress as it will not parse
  104.         // our masks correctly eg. 255.255.0.0 is pased as 65535 !
  105.         private uint parseIP(string IPNumber) {
  106.             uint res = 0;
  107.             string[] elements = IPNumber.Split(new Char[] {'.'});
  108.             if (elements.Length==4) {
  109.                 res = (uint)Convert.ToInt32(elements[0])<<24;
  110.                 res += (uint)Convert.ToInt32(elements[1])<<16;
  111.                 res += (uint) Convert.ToInt32(elements[2])<<8;
  112.                 res += (uint) Convert.ToInt32(elements[3]);
  113.             }
  114.             return res;
  115.         }
  116.  
  117.         /// <summary>
  118.         /// Add a single IP number to the list as a string, ex. 10.1.1.1
  119.         /// </summary>
  120.         public void Add(string ipNumber) {
  121.             this.Add(parseIP(ipNumber));
  122.         }
  123.  
  124.         /// <summary>
  125.         /// Add a single IP number to the list as a unsigned integer, ex. 0x0A010101
  126.         /// </summary>
  127.         public void Add(uint ip) {
  128.             ((IPArrayList)ipRangeList[31]).Add(ip);
  129.             if (!usedList.Contains((int)31)) {
  130.                 usedList.Add((int)31);
  131.                 usedList.Sort();
  132.             }
  133.         }
  134.  
  135.         /// <summary>
  136.         /// Adds IP numbers using a mask for range where the mask specifies the number of
  137.         /// fixed bits, ex. 172.16.0.0 255.255.0.0 will add 172.16.0.0 - 172.16.255.255
  138.         /// </summary>
  139.         public void Add(string ipNumber, string mask) {
  140.             this.Add(parseIP(ipNumber),parseIP(mask));
  141.         }
  142.  
  143.         /// <summary>
  144.         /// Adds IP numbers using a mask for range where the mask specifies the number of
  145.         /// fixed bits, ex. 0xAC1000 0xFFFF0000 will add 172.16.0.0 - 172.16.255.255
  146.         /// </summary>
  147.         public void Add(uint ip, uint umask) {
  148.             object Level = maskList[umask];
  149.             if (Level!=null) {
  150.                 ip = ip & umask;
  151.                 ((IPArrayList)ipRangeList[(int)Level-1]).Add(ip);
  152.                 if (!usedList.Contains((int)Level-1)) {
  153.                     usedList.Add((int)Level-1);
  154.                     usedList.Sort();
  155.                 }
  156.             }
  157.         }
  158.  
  159.         /// <summary>
  160.         /// Adds IP numbers using a mask for range where the mask specifies the number of
  161.         /// fixed bits, ex. 192.168.1.0/24 which will add 192.168.1.0 - 192.168.1.255
  162.         /// </summary>
  163.         public void Add(string ipNumber, int maskLevel) {
  164.             this.Add(parseIP(ipNumber),(uint)maskList.GetKey(maskList.IndexOfValue(maskLevel)));
  165.         }
  166.  
  167.         /// <summary>
  168.         /// Adds IP numbers using a from and to IP number. The method checks the range and
  169.         /// splits it into normal ip/mask blocks.
  170.         /// </summary>
  171.         public void AddRange(string fromIP, string toIP) {
  172.             this.AddRange(parseIP(fromIP),parseIP(toIP));
  173.         }
  174.  
  175.         /// <summary>
  176.         /// Adds IP numbers using a from and to IP number. The method checks the range and
  177.         /// splits it into normal ip/mask blocks.
  178.         /// </summary>
  179.         public void AddRange(uint fromIP, uint toIP) {
  180.             // If the order is not asending, switch the IP numbers.
  181.             if (fromIP>toIP) {
  182.                 uint tempIP = fromIP;
  183.                 fromIP=toIP;
  184.                 toIP=tempIP;
  185.             }
  186.             if (fromIP==toIP) {
  187.                 this.Add(fromIP);
  188.             } else {
  189.                 uint diff = toIP-fromIP;
  190.                 int diffLevel = 1;
  191.                 uint range = 0x80000000;
  192.                 if (diff<256) {
  193.                     diffLevel = 24;
  194.                     range = 0x00000100;
  195.                 }
  196.                 while (range>diff) {
  197.                     range = range>>1;
  198.                     diffLevel++;
  199.                 }
  200.                 uint mask = (uint)maskList.GetKey(maskList.IndexOfValue(diffLevel));
  201.                 uint minIP = fromIP & mask;
  202.                 if (minIP<fromIP) minIP+=range;
  203.                 if (minIP>fromIP) {
  204.                     this.AddRange(fromIP,minIP-1);
  205.                     fromIP=minIP;
  206.                 }
  207.                 if (fromIP==toIP) {
  208.                     this.Add(fromIP);
  209.                 } else {
  210.                     if ((minIP+(range-1))<=toIP) {
  211.                         this.Add(minIP,mask);
  212.                         fromIP = minIP+range;
  213.                     }
  214.                     if (fromIP==toIP) {
  215.                         this.Add(toIP);
  216.                     } else {
  217.                         if (fromIP<toIP) this.AddRange(fromIP,toIP);
  218.                     }
  219.                 }
  220.             }
  221.         }
  222.  
  223.         /// <summary>
  224.         /// Checks if an IP number is contained in the lists, ex. 10.0.0.1
  225.         /// </summary>
  226.         public bool CheckNumber(string ipNumber) {
  227.             return this.CheckNumber(parseIP(ipNumber));;
  228.         }
  229.  
  230.         /// <summary>
  231.         /// Checks if an IP number is contained in the lists, ex. 0x0A000001
  232.         /// </summary>
  233.         public bool CheckNumber(uint ip) {
  234.             bool found = false;
  235.             int i=0;
  236.             while (!found && i<usedList.Count) {
  237.                 found = ((IPArrayList)ipRangeList[(int)usedList[i]]).Check(ip);
  238.                 i++;
  239.             }
  240.             return found;
  241.         }
  242.  
  243.         /// <summary>
  244.         /// Clears all lists of IP numbers
  245.         /// </summary>
  246.         public void Clear() {
  247.             foreach (int i in usedList) {
  248.                 ((IPArrayList)ipRangeList[i]).Clear();
  249.             }
  250.             usedList.Clear();
  251.         }
  252.  
  253.         /// <summary>
  254.         /// Generates a list of all IP ranges in printable format
  255.         /// </summary>
  256.         public override string ToString() {
  257.             StringBuilder buffer = new StringBuilder();
  258.             foreach (int i in usedList) {
  259.                 buffer.Append("\r\nRange with mask of ").Append(i+1).Append("\r\n");
  260.                 buffer.Append(((IPArrayList)ipRangeList[i]).ToString());
  261.             }
  262.             return buffer.ToString();
  263.         }
  264.  
  265.  
  266.     }
  267. }
  268.